home *** CD-ROM | disk | FTP | other *** search
/ PD Collection CD 1 / PD Collection CD 1.iso / textual / tex / files / !tex / TeXsource / web2ctex / ctex / c / tex8 < prev    next >
Encoding:
Text File  |  1989-09-20  |  44.2 KB  |  2,066 lines
  1. #define EXTERN extern
  2. #include "texd.h"
  3.  
  4. alteraux () {
  5.     alteraux_regmem 
  6.   halfword c  ; 
  7.   if ( curchr != abs ( curlist .modefield ) ) 
  8.   reportillegalcase () ; 
  9.   else {
  10.       
  11.     c = curchr ; 
  12.     scanoptionalequals () ; 
  13.     if ( c == 1 ) 
  14.     {
  15.       scandimen ( false , false , false ) ; 
  16.       curlist .auxfield = curval ; 
  17.     } 
  18.     else {
  19.     
  20.       scanint () ; 
  21.       if ( ( curval <= 0 ) || ( curval > 32767 ) ) 
  22.       {
  23.     {
  24.       if ( interaction == 3 ) 
  25.       wakeupterminal () ; 
  26.       printnl ( 133 ) ; 
  27.       print ( 1059 ) ; 
  28.     } 
  29.     {
  30.       helpptr = 1 ; 
  31.       helpline [ 0 ] = 1060 ; 
  32.     } 
  33.     interror ( curval ) ; 
  34.       } 
  35.       else curlist .auxfield = curval ; 
  36.     } 
  37.   } 
  38. } 
  39. alterprevgraf () {
  40.     alterprevgraf_regmem 
  41.   integer p  ; 
  42.   nest [ nestptr ] = curlist ; 
  43.   p = nestptr ; 
  44.   while ( abs ( nest [ p ] .modefield ) != 1 ) decr ( p ) ; 
  45.   scanoptionalequals () ; 
  46.   scanint () ; 
  47.   if ( curval < 0 ) 
  48.   {
  49.     {
  50.       if ( interaction == 3 ) 
  51.       wakeupterminal () ; 
  52.       printnl ( 133 ) ; 
  53.       print ( 802 ) ; 
  54.     } 
  55.     printesc ( 390 ) ; 
  56.     {
  57.       helpptr = 1 ; 
  58.       helpline [ 0 ] = 1061 ; 
  59.     } 
  60.     interror ( curval ) ; 
  61.   } 
  62.   else {
  63.       
  64.     nest [ p ] .pgfield = curval ; 
  65.     curlist = nest [ nestptr ] ; 
  66.   } 
  67. } 
  68. alterpagesofar () {
  69.     alterpagesofar_regmem 
  70.   schar c  ; 
  71.   c = curchr ; 
  72.   scanoptionalequals () ; 
  73.   scandimen ( false , false , false ) ; 
  74.   pagesofar [ c ] = curval ; 
  75. } 
  76. alterinteger () {
  77.     alterinteger_regmem 
  78.   schar c  ; 
  79.   c = curchr ; 
  80.   scanoptionalequals () ; 
  81.   scanint () ; 
  82.   if ( c == 0 ) 
  83.   deadcycles = curval ; 
  84.   else insertpenalties = curval ; 
  85. } 
  86. alterboxdimen () {
  87.     alterboxdimen_regmem 
  88.   smallnumber c  ; 
  89.   eightbits b  ; 
  90.   c = curchr ; 
  91.   scaneightbitint () ; 
  92.   b = curval ; 
  93.   scanoptionalequals () ; 
  94.   scandimen ( false , false , false ) ; 
  95.   if ( eqtb [ 4322 + b ] .hh .v.RH != 0 ) 
  96.   mem [ eqtb [ 4322 + b ] .hh .v.RH + c ] .cint = curval ; 
  97. } 
  98. znewfont ( a ) 
  99. smallnumber a ; 
  100. {/* 50 */ newfont_regmem 
  101.   halfword u  ; 
  102.   scaled s  ; 
  103.   internalfontnumber f  ; 
  104.   strnumber t  ; 
  105.   schar oldsetting  ; 
  106.   if ( jobname == 0 ) 
  107.   openlogfile () ; 
  108.   getrtoken () ; 
  109.   u = curcs ; 
  110.   if ( u >= 258 ) 
  111.   t = hash [ u ] .v.RH ; 
  112.   else if ( u >= 129 ) 
  113.   if ( u == 257 ) 
  114.   t = 1065 ; 
  115.   else t = u - 129 ; 
  116.   else {
  117.       
  118.     oldsetting = selector ; 
  119.     selector = 21 ; 
  120.     print ( 1065 ) ; 
  121.     print ( u - 1 ) ; 
  122.     selector = oldsetting ; 
  123.     {
  124.       if ( poolptr + 1 > poolsize ) 
  125.       overflow ( 128 , poolsize - initpoolptr ) ; 
  126.     } 
  127.     t = makestring () ; 
  128.   } 
  129.   if ( ( a >= 4 ) ) 
  130.   geqdefine ( u , 86 , 0 ) ; 
  131.   else eqdefine ( u , 86 , 0 ) ; 
  132.   scanoptionalequals () ; 
  133.   scanfilename () ; 
  134.   nameinprogress = true ; 
  135.   if ( scankeyword ( 1066 ) ) 
  136.   {
  137.     scandimen ( false , false , false ) ; 
  138.     s = curval ; 
  139.     if ( ( s <= 0 ) || ( s >= 134217728L ) ) 
  140.     {
  141.       {
  142.     if ( interaction == 3 ) 
  143.     wakeupterminal () ; 
  144.     printnl ( 133 ) ; 
  145.     print ( 1068 ) ; 
  146.       } 
  147.       printscaled ( s ) ; 
  148.       print ( 1069 ) ; 
  149.       {
  150.     helpptr = 2 ; 
  151.     helpline [ 1 ] = 1070 ; 
  152.     helpline [ 0 ] = 1071 ; 
  153.       } 
  154.       error () ; 
  155.       s = 10 * 65536L ; 
  156.     } 
  157.   } 
  158.   else if ( scankeyword ( 1067 ) ) 
  159.   {
  160.     scanint () ; 
  161.     s = - (integer) curval ; 
  162.     if ( ( curval <= 0 ) || ( curval > 32768L ) ) 
  163.     {
  164.       {
  165.     if ( interaction == 3 ) 
  166.     wakeupterminal () ; 
  167.     printnl ( 133 ) ; 
  168.     print ( 410 ) ; 
  169.       } 
  170.       {
  171.     helpptr = 1 ; 
  172.     helpline [ 0 ] = 411 ; 
  173.       } 
  174.       interror ( curval ) ; 
  175.       s = -1000 ; 
  176.     } 
  177.   } 
  178.   else s = -1000 ; 
  179.   nameinprogress = false ; 
  180.   {register integer for_end; f = 1 ; for_end = fontptr ; if ( f <= for_end) 
  181.   do 
  182.     if ( streqstr ( fontname [ f ] , curname ) && streqstr ( fontarea [ f ] , 
  183.     curarea ) ) 
  184.     {
  185.       if ( s > 0 ) 
  186.       {
  187.     if ( s == fontsize [ f ] ) 
  188.     goto lab50 ; 
  189.       } 
  190.       else if ( fontsize [ f ] == xnoverd ( fontdsize [ f ] , - (integer) s , 
  191.       1000 ) ) 
  192.       goto lab50 ; 
  193.     } 
  194.   while ( f++ < for_end ) ; } 
  195.   f = readfontinfo ( u , curname , curarea , s ) ; 
  196.   lab50: eqtb [ u ] .hh .v.RH = f ; 
  197.   eqtb [ 3268 + f ] = eqtb [ u ] ; 
  198.   hash [ 3268 + f ] .v.RH = t ; 
  199. } 
  200. newinteraction () {
  201.     newinteraction_regmem 
  202.   println () ; 
  203.   interaction = curchr ; 
  204.   if ( interaction == 0 ) 
  205.   selector = 16 ; 
  206.   else selector = 17 ; 
  207.   if ( jobname != 0 ) 
  208.   selector = selector + 2 ; 
  209. } 
  210. doassignments () {
  211.     /* 10 */ doassignments_regmem 
  212.   while ( true ) {
  213.       
  214.     do {
  215.     getxtoken () ; 
  216.     } while ( ! ( ( curcmd != 10 ) && ( curcmd != 0 ) ) ) ; 
  217.     if ( curcmd <= 69 ) 
  218.     return ; 
  219.     prefixedcommand () ; 
  220.   } 
  221. } 
  222. openorclosein () {
  223.     openorclosein_regmem 
  224.   schar c  ; 
  225.   schar n  ; 
  226.   c = curchr ; 
  227.   scanfourbitint () ; 
  228.   n = curval ; 
  229.   if ( readopen [ n ] != 2 ) 
  230.   {
  231.     aclose ( readfile [ n ] ) ; 
  232.     readopen [ n ] = 2 ; 
  233.   } 
  234.   if ( c != 0 ) 
  235.   {
  236.     scanoptionalequals () ; 
  237.     scanfilename () ; 
  238.     if ( curext == 206 ) 
  239.     curext = 644 ; 
  240.     packfilename ( curname , curarea , curext ) ; 
  241.     if ( aopenin ( readfile [ n ] , readpathspec ) ) 
  242.     readopen [ n ] = 1 ; 
  243.   } 
  244. } 
  245. issuemessage () {
  246.     issuemessage_regmem 
  247.   schar oldsetting  ; 
  248.   schar c  ; 
  249.   strnumber s  ; 
  250.   c = curchr ; 
  251.   mem [ memtop - 12 ] .hh .v.RH = scantoks ( false , true ) ; 
  252.   oldsetting = selector ; 
  253.   selector = 21 ; 
  254.   tokenshow ( defref ) ; 
  255.   selector = oldsetting ; 
  256.   flushlist ( defref ) ; 
  257.   {
  258.     if ( poolptr + 1 > poolsize ) 
  259.     overflow ( 128 , poolsize - initpoolptr ) ; 
  260.   } 
  261.   s = makestring () ; 
  262.   if ( c == 0 ) 
  263.   {
  264.     if ( termoffset + ( strstart [ s + 1 ] - strstart [ s ] ) > maxprintline - 
  265.     2 ) 
  266.     println () ; 
  267.     else if ( ( termoffset > 0 ) || ( fileoffset > 0 ) ) 
  268.     printchar ( 32 ) ; 
  269.     print ( s ) ; 
  270.     termflush ( stdout ) ; 
  271.   } 
  272.   else {
  273.       
  274.     {
  275.       if ( interaction == 3 ) 
  276.       wakeupterminal () ; 
  277.       printnl ( 133 ) ; 
  278.       print ( s ) ; 
  279.     } 
  280.     if ( eqtb [ 4065 ] .hh .v.RH != 0 ) 
  281.     useerrhelp = true ; 
  282.     else if ( longhelpseen ) 
  283.     {
  284.       helpptr = 1 ; 
  285.       helpline [ 0 ] = 1078 ; 
  286.     } 
  287.     else {
  288.     
  289.       if ( interaction < 3 ) 
  290.       longhelpseen = true ; 
  291.       {
  292.     helpptr = 4 ; 
  293.     helpline [ 3 ] = 1079 ; 
  294.     helpline [ 2 ] = 1080 ; 
  295.     helpline [ 1 ] = 1081 ; 
  296.     helpline [ 0 ] = 1082 ; 
  297.       } 
  298.     } 
  299.     error () ; 
  300.     useerrhelp = false ; 
  301.   } 
  302.   {
  303.     decr ( strptr ) ; 
  304.     poolptr = strstart [ strptr ] ; 
  305.   } 
  306. } 
  307. shiftcase () {
  308.     shiftcase_regmem 
  309.   halfword b  ; 
  310.   halfword p  ; 
  311.   halfword t  ; 
  312.   eightbits c  ; 
  313.   b = curchr ; 
  314.   p = scantoks ( false , false ) ; 
  315.   p = mem [ defref ] .hh .v.RH ; 
  316.   while ( p != 0 ) {
  317.       
  318.     t = mem [ p ] .hh .v.LH ; 
  319.     if ( t < 4225 ) 
  320.     {
  321.       if ( t >= 4096 ) 
  322.       t = t - 1 ; 
  323.       c = t % 256 ; 
  324.       if ( c < 128 ) 
  325.       if ( eqtb [ b + c ] .hh .v.RH != 0 ) 
  326.       t = 256 * ( t / 256 ) + eqtb [ b + c ] .hh .v.RH ; 
  327.       if ( t >= 4096 ) 
  328.       mem [ p ] .hh .v.LH = t + 1 ; 
  329.       else mem [ p ] .hh .v.LH = t ; 
  330.     } 
  331.     p = mem [ p ] .hh .v.RH ; 
  332.   } 
  333.   begintokenlist ( mem [ defref ] .hh .v.RH , 3 ) ; 
  334.   {
  335.     mem [ defref ] .hh .v.RH = avail ; 
  336.     avail = defref ; 
  337.     ;
  338. #ifdef STAT
  339.     decr ( dynused ) ; 
  340. #endif /* STAT */
  341.   } 
  342. } 
  343. showwhatever () {
  344.     /* 50 */ showwhatever_regmem 
  345.   halfword p  ; 
  346.   switch ( curchr ) 
  347.   {case 3 : 
  348.     {
  349.       begindiagnostic () ; 
  350.       showactivities () ; 
  351.     } 
  352.     break ; 
  353.   case 1 : 
  354.     {
  355.       scaneightbitint () ; 
  356.       begindiagnostic () ; 
  357.       printnl ( 1100 ) ; 
  358.       printint ( curval ) ; 
  359.       printchar ( 61 ) ; 
  360.       if ( eqtb [ 4322 + curval ] .hh .v.RH == 0 ) 
  361.       print ( 275 ) ; 
  362.       else showbox ( eqtb [ 4322 + curval ] .hh .v.RH ) ; 
  363.     } 
  364.     break ; 
  365.   case 0 : 
  366.     {
  367.       gettoken () ; 
  368.       if ( interaction == 3 ) 
  369.       wakeupterminal () ; 
  370.       printnl ( 1094 ) ; 
  371.       if ( curcs != 0 ) 
  372.       {
  373.     sprintcs ( curcs ) ; 
  374.     printchar ( 61 ) ; 
  375.       } 
  376.       printmeaning () ; 
  377.       goto lab50 ; 
  378.     } 
  379.     break ; 
  380.     default: 
  381.     {
  382.       p = thetoks () ; 
  383.       if ( interaction == 3 ) 
  384.       wakeupterminal () ; 
  385.       printnl ( 1094 ) ; 
  386.       tokenshow ( memtop - 3 ) ; 
  387.       flushlist ( mem [ memtop - 3 ] .hh .v.RH ) ; 
  388.       goto lab50 ; 
  389.     } 
  390.     break ; 
  391.   } 
  392.   enddiagnostic ( true ) ; 
  393.   {
  394.     if ( interaction == 3 ) 
  395.     wakeupterminal () ; 
  396.     printnl ( 133 ) ; 
  397.     print ( 1101 ) ; 
  398.   } 
  399.   if ( selector == 19 ) 
  400.   if ( eqtb [ 5296 ] .cint <= 0 ) 
  401.   {
  402.     selector = 17 ; 
  403.     print ( 1102 ) ; 
  404.     selector = 19 ; 
  405.   } 
  406.   lab50: if ( interaction < 3 ) 
  407.   {
  408.     helpptr = 0 ; 
  409.     decr ( errorcount ) ; 
  410.   } 
  411.   else if ( eqtb [ 5296 ] .cint > 0 ) 
  412.   {
  413.     {
  414.       helpptr = 3 ; 
  415.       helpline [ 2 ] = 1089 ; 
  416.       helpline [ 1 ] = 1090 ; 
  417.       helpline [ 0 ] = 1091 ; 
  418.     } 
  419.   } 
  420.   else {
  421.       
  422.     {
  423.       helpptr = 5 ; 
  424.       helpline [ 4 ] = 1089 ; 
  425.       helpline [ 3 ] = 1090 ; 
  426.       helpline [ 2 ] = 1091 ; 
  427.       helpline [ 1 ] = 1092 ; 
  428.       helpline [ 0 ] = 1093 ; 
  429.     } 
  430.   } 
  431.   error () ; 
  432. } 
  433. znewwhatsit ( s , w ) 
  434. smallnumber s ; 
  435. smallnumber w ; 
  436. {newwhatsit_regmem 
  437.   halfword p  ; 
  438.   p = getnode ( w ) ; 
  439.   mem [ p ] .hh.b0 = 8 ; 
  440.   mem [ p ] .hh.b1 = s ; 
  441.   mem [ curlist .tailfield ] .hh .v.RH = p ; 
  442.   curlist .tailfield = p ; 
  443. } 
  444. znewwritewhatsit ( w ) 
  445. smallnumber w ; 
  446. {newwritewhatsit_regmem 
  447.   newwhatsit ( curchr , w ) ; 
  448.   if ( w != 2 ) 
  449.   scanfourbitint () ; 
  450.   else {
  451.       
  452.     scanint () ; 
  453.     if ( curval < 0 ) 
  454.     curval = 17 ; 
  455.     else if ( curval > 15 ) 
  456.     curval = 16 ; 
  457.   } 
  458.   mem [ curlist .tailfield + 1 ] .hh .v.LH = curval ; 
  459. } 
  460. doextension () {
  461.     doextension_regmem 
  462.   integer i, j, k  ; 
  463.   halfword p, q, r  ; 
  464.   switch ( curchr ) 
  465.   {case 0 : 
  466.     {
  467.       newwritewhatsit ( 3 ) ; 
  468.       scanoptionalequals () ; 
  469.       scanfilename () ; 
  470.       mem [ curlist .tailfield + 1 ] .hh .v.RH = curname ; 
  471.       mem [ curlist .tailfield + 2 ] .hh .v.LH = curarea ; 
  472.       mem [ curlist .tailfield + 2 ] .hh .v.RH = curext ; 
  473.     } 
  474.     break ; 
  475.   case 1 : 
  476.     {
  477.       k = curcs ; 
  478.       newwritewhatsit ( 2 ) ; 
  479.       curcs = k ; 
  480.       p = scantoks ( false , false ) ; 
  481.       mem [ curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  482.     } 
  483.     break ; 
  484.   case 2 : 
  485.     {
  486.       newwritewhatsit ( 2 ) ; 
  487.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 0 ; 
  488.     } 
  489.     break ; 
  490.   case 3 : 
  491.     {
  492.       newwhatsit ( 3 , 2 ) ; 
  493.       mem [ curlist .tailfield + 1 ] .hh .v.LH = 0 ; 
  494.       p = scantoks ( false , true ) ; 
  495.       mem [ curlist .tailfield + 1 ] .hh .v.RH = defref ; 
  496.     } 
  497.     break ; 
  498.   case 4 : 
  499.     {
  500.       getxtoken () ; 
  501.       if ( ( curcmd == 59 ) && ( curchr <= 2 ) ) 
  502.       {
  503.     p = curlist .tailfield ; 
  504.     doextension () ; 
  505.     outwhat ( curlist .tailfield ) ; 
  506.     flushnodelist ( curlist .tailfield ) ; 
  507.     curlist .tailfield = p ; 
  508.     mem [ p ] .hh .v.RH = 0 ; 
  509.       } 
  510.       else backinput () ; 
  511.     } 
  512.     break ; 
  513.     default: 
  514.     confusion ( 1134 ) ; 
  515.     break ; 
  516.   } 
  517. } 
  518. handlerightbrace () {
  519.     handlerightbrace_regmem 
  520.   halfword p, q  ; 
  521.   scaled d  ; 
  522.   integer f  ; 
  523.   switch ( curgroup ) 
  524.   {case 1 : 
  525.     unsave () ; 
  526.     break ; 
  527.   case 0 : 
  528.     {
  529.       {
  530.     if ( interaction == 3 ) 
  531.     wakeupterminal () ; 
  532.     printnl ( 133 ) ; 
  533.     print ( 892 ) ; 
  534.       } 
  535.       {
  536.     helpptr = 2 ; 
  537.     helpline [ 1 ] = 893 ; 
  538.     helpline [ 0 ] = 894 ; 
  539.       } 
  540.       error () ; 
  541.     } 
  542.     break ; 
  543.   case 14 : 
  544.   case 15 : 
  545.   case 16 : 
  546.     extrarightbrace () ; 
  547.     break ; 
  548.   case 2 : 
  549.     package ( 0 ) ; 
  550.     break ; 
  551.   case 3 : 
  552.     {
  553.       adjusttail = memtop - 5 ; 
  554.       package ( 0 ) ; 
  555.     } 
  556.     break ; 
  557.   case 4 : 
  558.     {
  559.       endgraf () ; 
  560.       package ( 0 ) ; 
  561.     } 
  562.     break ; 
  563.   case 5 : 
  564.     {
  565.       endgraf () ; 
  566.       package ( 4 ) ; 
  567.     } 
  568.     break ; 
  569.   case 11 : 
  570.     {
  571.       endgraf () ; 
  572.       q = eqtb [ 3536 ] .hh .v.RH ; 
  573.       incr ( mem [ q ] .hh .v.RH ) ; 
  574.       d = eqtb [ 5707 ] .cint ; 
  575.       f = eqtb [ 5309 ] .cint ; 
  576.       unsave () ; 
  577.       decr ( saveptr ) ; 
  578.       p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , 0 , 1 , 
  579.       1073741823L ) ; 
  580.       popnest () ; 
  581.       if ( savestack [ saveptr + 0 ] .cint < 255 ) 
  582.       {
  583.     {
  584.       mem [ curlist .tailfield ] .hh .v.RH = getnode ( 5 ) ; 
  585.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  586.     } 
  587.     mem [ curlist .tailfield ] .hh.b0 = 3 ; 
  588.     mem [ curlist .tailfield ] .hh.b1 = savestack [ saveptr + 0 ] .cint ; 
  589.     mem [ curlist .tailfield + 3 ] .cint = mem [ p + 3 ] .cint + mem [ p + 
  590.     2 ] .cint ; 
  591.     mem [ curlist .tailfield + 4 ] .hh .v.LH = mem [ p + 5 ] .hh .v.RH ; 
  592.     mem [ curlist .tailfield + 4 ] .hh .v.RH = q ; 
  593.     mem [ curlist .tailfield + 2 ] .cint = d ; 
  594.     mem [ curlist .tailfield + 1 ] .cint = f ; 
  595.       } 
  596.       else {
  597.       
  598.     {
  599.       mem [ curlist .tailfield ] .hh .v.RH = getnode ( 2 ) ; 
  600.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  601.     } 
  602.     mem [ curlist .tailfield ] .hh.b0 = 5 ; 
  603.     mem [ curlist .tailfield ] .hh.b1 = 0 ; 
  604.     mem [ curlist .tailfield + 1 ] .cint = mem [ p + 5 ] .hh .v.RH ; 
  605.     deleteglueref ( q ) ; 
  606.       } 
  607.       freenode ( p , 7 ) ; 
  608.       if ( nestptr == 0 ) 
  609.       buildpage () ; 
  610.     } 
  611.     break ; 
  612.   case 8 : 
  613.     {
  614.       if ( curinput .locfield != 0 ) 
  615.       {
  616.     {
  617.       if ( interaction == 3 ) 
  618.       wakeupterminal () ; 
  619.       printnl ( 133 ) ; 
  620.       print ( 858 ) ; 
  621.     } 
  622.     {
  623.       helpptr = 2 ; 
  624.       helpline [ 1 ] = 859 ; 
  625.       helpline [ 0 ] = 860 ; 
  626.     } 
  627.     error () ; 
  628.     do {
  629.         gettoken () ; 
  630.     } while ( ! ( curinput .locfield == 0 ) ) ; 
  631.       } 
  632.       endtokenlist () ; 
  633.       endgraf () ; 
  634.       unsave () ; 
  635.       outputactive = false ; 
  636.       insertpenalties = 0 ; 
  637.       if ( eqtb [ 4577 ] .hh .v.RH != 0 ) 
  638.       {
  639.     {
  640.       if ( interaction == 3 ) 
  641.       wakeupterminal () ; 
  642.       printnl ( 133 ) ; 
  643.       print ( 861 ) ; 
  644.     } 
  645.     printesc ( 274 ) ; 
  646.     printint ( 255 ) ; 
  647.     {
  648.       helpptr = 3 ; 
  649.       helpline [ 2 ] = 862 ; 
  650.       helpline [ 1 ] = 863 ; 
  651.       helpline [ 0 ] = 864 ; 
  652.     } 
  653.     boxerror ( 255 ) ; 
  654.       } 
  655.       if ( curlist .tailfield != curlist .headfield ) 
  656.       {
  657.     mem [ pagetail ] .hh .v.RH = mem [ curlist .headfield ] .hh .v.RH ; 
  658.     pagetail = curlist .tailfield ; 
  659.       } 
  660.       if ( mem [ memtop - 2 ] .hh .v.RH != 0 ) 
  661.       {
  662.     if ( mem [ memtop - 1 ] .hh .v.RH == 0 ) 
  663.     nest [ 0 ] .tailfield = pagetail ; 
  664.     mem [ pagetail ] .hh .v.RH = mem [ memtop - 1 ] .hh .v.RH ; 
  665.     mem [ memtop - 1 ] .hh .v.RH = mem [ memtop - 2 ] .hh .v.RH ; 
  666.     mem [ memtop - 2 ] .hh .v.RH = 0 ; 
  667.     pagetail = memtop - 2 ; 
  668.       } 
  669.       popnest () ; 
  670.       buildpage () ; 
  671.     } 
  672.     break ; 
  673.   case 10 : 
  674.     builddiscretionary () ; 
  675.     break ; 
  676.   case 6 : 
  677.     {
  678.       backinput () ; 
  679.       curtok = 7355 ; 
  680.       {
  681.     if ( interaction == 3 ) 
  682.     wakeupterminal () ; 
  683.     printnl ( 133 ) ; 
  684.     print ( 483 ) ; 
  685.       } 
  686.       printesc ( 752 ) ; 
  687.       print ( 484 ) ; 
  688.       {
  689.     helpptr = 1 ; 
  690.     helpline [ 0 ] = 973 ; 
  691.       } 
  692.       inserror () ; 
  693.     } 
  694.     break ; 
  695.   case 7 : 
  696.     {
  697.       endgraf () ; 
  698.       unsave () ; 
  699.       alignpeek () ; 
  700.     } 
  701.     break ; 
  702.   case 12 : 
  703.     {
  704.       endgraf () ; 
  705.       unsave () ; 
  706.       saveptr = saveptr - 2 ; 
  707.       p = vpackage ( mem [ curlist .headfield ] .hh .v.RH , savestack [ 
  708.       saveptr + 1 ] .cint , savestack [ saveptr + 0 ] .cint , 1073741823L ) ; 
  709.       popnest () ; 
  710.       {
  711.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  712.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  713.       } 
  714.       mem [ curlist .tailfield ] .hh.b0 = 29 ; 
  715.       mem [ curlist .tailfield + 1 ] .hh .v.RH = 2 ; 
  716.       mem [ curlist .tailfield + 1 ] .hh .v.LH = p ; 
  717.     } 
  718.     break ; 
  719.   case 13 : 
  720.     buildchoices () ; 
  721.     break ; 
  722.   case 9 : 
  723.     {
  724.       unsave () ; 
  725.       decr ( saveptr ) ; 
  726.       mem [ savestack [ saveptr + 0 ] .cint ] .hh .v.RH = 3 ; 
  727.       p = finmlist ( 0 ) ; 
  728.       mem [ savestack [ saveptr + 0 ] .cint ] .hh .v.LH = p ; 
  729.       if ( p != 0 ) 
  730.       if ( mem [ p ] .hh .v.RH == 0 ) 
  731.       if ( mem [ p ] .hh.b0 == 16 ) 
  732.       {
  733.     if ( mem [ p + 3 ] .hh .v.RH == 0 ) 
  734.     if ( mem [ p + 2 ] .hh .v.RH == 0 ) 
  735.     {
  736.       mem [ savestack [ saveptr + 0 ] .cint ] .hh = mem [ p + 1 ] .hh ; 
  737.       freenode ( p , 4 ) ; 
  738.     } 
  739.       } 
  740.       else if ( mem [ p ] .hh.b0 == 28 ) 
  741.       if ( savestack [ saveptr + 0 ] .cint == curlist .tailfield + 1 ) 
  742.       if ( mem [ curlist .tailfield ] .hh.b0 == 16 ) 
  743.       {
  744.     q = curlist .headfield ; 
  745.     while ( mem [ q ] .hh .v.RH != curlist .tailfield ) q = mem [ q ] .hh 
  746.     .v.RH ; 
  747.     mem [ q ] .hh .v.RH = p ; 
  748.     freenode ( curlist .tailfield , 4 ) ; 
  749.     curlist .tailfield = p ; 
  750.       } 
  751.     } 
  752.     break ; 
  753.     default: 
  754.     confusion ( 895 ) ; 
  755.     break ; 
  756.   } 
  757. } 
  758. maincontrol () {
  759.     /* 60 21 70 71 72 73 74 10 */ maincontrol_regmem 
  760.   integer t  ; 
  761.   quarterword l  ; 
  762.   eightbits c  ; 
  763.   internalfontnumber f  ; 
  764.   halfword r  ; 
  765.   halfword p  ; 
  766.   integer k  ; 
  767.   halfword q  ; 
  768.   fourquarters i  ; 
  769.   fourquarters j  ; 
  770.   integer s  ; 
  771.   boolean ligaturepresent  ; 
  772.   if ( eqtb [ 4063 ] .hh .v.RH != 0 ) 
  773.   begintokenlist ( eqtb [ 4063 ] .hh .v.RH , 12 ) ; 
  774.   lab60: getxtoken () ; 
  775.   lab21: if ( interrupt != 0 ) 
  776.   if ( OKtointerrupt ) 
  777.   {
  778.     backinput () ; 
  779.     {
  780.       if ( interrupt != 0 ) 
  781.       pauseforinstructions () ; 
  782.     } 
  783.     goto lab60 ; 
  784.   } 
  785.     ;
  786. #ifdef DEBUG
  787.   if ( panicking ) 
  788.   checkmem ( false ) ; 
  789. #endif /* DEBUG */
  790.   if ( eqtb [ 5303 ] .cint > 0 ) 
  791.   showcurcmdchr () ; 
  792.   switch ( abs ( curlist .modefield ) + curcmd ) 
  793.   {case 112 : 
  794.   case 113 : 
  795.   case 168 : 
  796.     goto lab70 ; 
  797.     break ; 
  798.   case 117 : 
  799.     {
  800.       scancharnum () ; 
  801.       curchr = curval ; 
  802.       goto lab70 ; 
  803.     } 
  804.     break ; 
  805.   case 111 : 
  806.     if ( curlist .auxfield == 1000 ) 
  807.     goto lab74 ; 
  808.     else appspace () ; 
  809.     break ; 
  810.   case 165 : 
  811.   case 265 : 
  812.     goto lab74 ; 
  813.     break ; 
  814.   case 1 : 
  815.   case 101 : 
  816.   case 201 : 
  817.   case 11 : 
  818.   case 211 : 
  819.     ; 
  820.     break ; 
  821.   case 40 : 
  822.   case 140 : 
  823.   case 240 : 
  824.     {
  825.       do {
  826.       getxtoken () ; 
  827.       } while ( ! ( curcmd != 10 ) ) ; 
  828.       goto lab21 ; 
  829.     } 
  830.     break ; 
  831.   case 15 : 
  832.     if ( itsallover () ) 
  833.     return ; 
  834.     break ; 
  835.   case 23 : 
  836.   case 122 : 
  837.   case 222 : 
  838.   case 70 : 
  839.   case 170 : 
  840.   case 270 : 
  841.   case 39 : 
  842.   case 45 : 
  843.   case 49 : 
  844.   case 149 : 
  845.   case 7 : 
  846.   case 107 : 
  847.   case 207 : 
  848.     reportillegalcase () ; 
  849.     break ; 
  850.   case 8 : 
  851.   case 108 : 
  852.   case 9 : 
  853.   case 109 : 
  854.   case 18 : 
  855.   case 118 : 
  856.   case 69 : 
  857.   case 169 : 
  858.   case 51 : 
  859.   case 151 : 
  860.   case 16 : 
  861.   case 116 : 
  862.   case 50 : 
  863.   case 150 : 
  864.   case 53 : 
  865.   case 153 : 
  866.   case 66 : 
  867.   case 166 : 
  868.   case 54 : 
  869.   case 154 : 
  870.   case 55 : 
  871.   case 155 : 
  872.   case 57 : 
  873.   case 157 : 
  874.   case 56 : 
  875.   case 156 : 
  876.   case 31 : 
  877.   case 131 : 
  878.   case 52 : 
  879.   case 152 : 
  880.   case 29 : 
  881.   case 129 : 
  882.   case 47 : 
  883.   case 147 : 
  884.   case 210 : 
  885.   case 214 : 
  886.   case 215 : 
  887.   case 228 : 
  888.   case 225 : 
  889.   case 234 : 
  890.   case 237 : 
  891.     insertdollarsign () ; 
  892.     break ; 
  893.   case 37 : 
  894.   case 136 : 
  895.   case 236 : 
  896.     {
  897.       {
  898.     mem [ curlist .tailfield ] .hh .v.RH = scanrulespec () ; 
  899.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  900.       } 
  901.       if ( abs ( curlist .modefield ) == 1 ) 
  902.       curlist .auxfield = -65536000L ; 
  903.       else if ( abs ( curlist .modefield ) == 101 ) 
  904.       curlist .auxfield = 1000 ; 
  905.     } 
  906.     break ; 
  907.   case 28 : 
  908.   case 127 : 
  909.   case 227 : 
  910.   case 229 : 
  911.     appendglue () ; 
  912.     break ; 
  913.   case 30 : 
  914.   case 130 : 
  915.   case 230 : 
  916.   case 231 : 
  917.     appendkern () ; 
  918.     break ; 
  919.   case 2 : 
  920.   case 102 : 
  921.     newsavelevel ( 1 ) ; 
  922.     break ; 
  923.   case 62 : 
  924.   case 162 : 
  925.   case 262 : 
  926.     newsavelevel ( 14 ) ; 
  927.     break ; 
  928.   case 63 : 
  929.   case 163 : 
  930.   case 263 : 
  931.     if ( curgroup == 14 ) 
  932.     unsave () ; 
  933.     else offsave () ; 
  934.     break ; 
  935.   case 3 : 
  936.   case 103 : 
  937.   case 203 : 
  938.     handlerightbrace () ; 
  939.     break ; 
  940.   case 22 : 
  941.   case 123 : 
  942.   case 223 : 
  943.     {
  944.       t = curchr ; 
  945.       scandimen ( false , false , false ) ; 
  946.       if ( t == 0 ) 
  947.       savestack [ saveptr + 0 ] .cint = curval ; 
  948.       else savestack [ saveptr + 0 ] .cint = - (integer) curval ; 
  949.       scanbox () ; 
  950.     } 
  951.     break ; 
  952.   case 32 : 
  953.   case 132 : 
  954.   case 232 : 
  955.     {
  956.       savestack [ saveptr + 0 ] .cint = 1073742237L + curchr ; 
  957.       scanbox () ; 
  958.     } 
  959.     break ; 
  960.   case 21 : 
  961.   case 121 : 
  962.   case 221 : 
  963.     {
  964.       savestack [ saveptr + 0 ] .cint = 0 ; 
  965.       beginbox () ; 
  966.     } 
  967.     break ; 
  968.   case 44 : 
  969.     newgraf ( curchr > 0 ) ; 
  970.     break ; 
  971.   case 12 : 
  972.   case 13 : 
  973.   case 17 : 
  974.   case 68 : 
  975.   case 4 : 
  976.   case 24 : 
  977.   case 36 : 
  978.   case 46 : 
  979.   case 48 : 
  980.   case 27 : 
  981.   case 34 : 
  982.   case 65 : 
  983.     {
  984.       backinput () ; 
  985.       newgraf ( true ) ; 
  986.     } 
  987.     break ; 
  988.   case 144 : 
  989.   case 244 : 
  990.     indentinhmode () ; 
  991.     break ; 
  992.   case 14 : 
  993.     {
  994.       normalparagraph () ; 
  995.       if ( curlist .modefield > 0 ) 
  996.       buildpage () ; 
  997.     } 
  998.     break ; 
  999.   case 114 : 
  1000.     {
  1001.       if ( alignstate < 0 ) 
  1002.       offsave () ; 
  1003.       endgraf () ; 
  1004.       if ( curlist .modefield == 1 ) 
  1005.       buildpage () ; 
  1006.     } 
  1007.     break ; 
  1008.   case 115 : 
  1009.   case 128 : 
  1010.   case 137 : 
  1011.   case 125 : 
  1012.   case 133 : 
  1013.     headforvmode () ; 
  1014.     break ; 
  1015.   case 38 : 
  1016.   case 138 : 
  1017.   case 238 : 
  1018.   case 139 : 
  1019.   case 239 : 
  1020.     begininsertoradjust () ; 
  1021.     break ; 
  1022.   case 19 : 
  1023.   case 119 : 
  1024.   case 219 : 
  1025.     makemark () ; 
  1026.     break ; 
  1027.   case 43 : 
  1028.   case 143 : 
  1029.   case 243 : 
  1030.     appendpenalty () ; 
  1031.     break ; 
  1032.   case 26 : 
  1033.   case 126 : 
  1034.   case 226 : 
  1035.     deletelast () ; 
  1036.     break ; 
  1037.   case 25 : 
  1038.   case 124 : 
  1039.   case 224 : 
  1040.     unpackage () ; 
  1041.     break ; 
  1042.   case 145 : 
  1043.     appenditaliccorrecti () ; 
  1044.     break ; 
  1045.   case 245 : 
  1046.     {
  1047.       mem [ curlist .tailfield ] .hh .v.RH = newkern ( 0 ) ; 
  1048.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1049.     } 
  1050.     break ; 
  1051.   case 148 : 
  1052.   case 248 : 
  1053.     appenddiscretionary () ; 
  1054.     break ; 
  1055.   case 146 : 
  1056.     makeaccent () ; 
  1057.     break ; 
  1058.   case 6 : 
  1059.   case 106 : 
  1060.   case 206 : 
  1061.   case 5 : 
  1062.   case 105 : 
  1063.   case 205 : 
  1064.     alignerror () ; 
  1065.     break ; 
  1066.   case 35 : 
  1067.   case 135 : 
  1068.   case 235 : 
  1069.     noalignerror () ; 
  1070.     break ; 
  1071.   case 64 : 
  1072.   case 164 : 
  1073.   case 264 : 
  1074.     omiterror () ; 
  1075.     break ; 
  1076.   case 33 : 
  1077.   case 134 : 
  1078.     initalign () ; 
  1079.     break ; 
  1080.   case 233 : 
  1081.     if ( privileged () ) 
  1082.     initalign () ; 
  1083.     break ; 
  1084.   case 10 : 
  1085.   case 110 : 
  1086.     doendv () ; 
  1087.     break ; 
  1088.   case 67 : 
  1089.   case 167 : 
  1090.   case 267 : 
  1091.     cserror () ; 
  1092.     break ; 
  1093.   case 104 : 
  1094.     initmath () ; 
  1095.     break ; 
  1096.   case 249 : 
  1097.     if ( privileged () ) 
  1098.     starteqno () ; 
  1099.     break ; 
  1100.   case 202 : 
  1101.     {
  1102.       {
  1103.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1104.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1105.       } 
  1106.       backinput () ; 
  1107.       scanmath ( curlist .tailfield + 1 ) ; 
  1108.     } 
  1109.     break ; 
  1110.   case 212 : 
  1111.   case 213 : 
  1112.   case 268 : 
  1113.     if ( curchr < 128 ) 
  1114.     setmathchar ( eqtb [ 5139 + curchr ] .hh .v.RH ) ; 
  1115.     else setmathchar ( curchr ) ; 
  1116.     break ; 
  1117.   case 217 : 
  1118.     {
  1119.       scancharnum () ; 
  1120.       curchr = curval ; 
  1121.       if ( curchr < 128 ) 
  1122.       setmathchar ( eqtb [ 5139 + curchr ] .hh .v.RH ) ; 
  1123.       else setmathchar ( curchr ) ; 
  1124.     } 
  1125.     break ; 
  1126.   case 218 : 
  1127.     {
  1128.       scanfifteenbitint () ; 
  1129.       setmathchar ( curval ) ; 
  1130.     } 
  1131.     break ; 
  1132.   case 269 : 
  1133.     setmathchar ( curchr ) ; 
  1134.     break ; 
  1135.   case 216 : 
  1136.     {
  1137.       scantwentysevenbitin () ; 
  1138.       setmathchar ( curval / 4096 ) ; 
  1139.     } 
  1140.     break ; 
  1141.   case 251 : 
  1142.     {
  1143.       {
  1144.     mem [ curlist .tailfield ] .hh .v.RH = newnoad () ; 
  1145.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1146.       } 
  1147.       mem [ curlist .tailfield ] .hh.b0 = curchr ; 
  1148.       scanmath ( curlist .tailfield + 1 ) ; 
  1149.     } 
  1150.     break ; 
  1151.   case 252 : 
  1152.     mathlimitswitch () ; 
  1153.     break ; 
  1154.   case 266 : 
  1155.     mathradical () ; 
  1156.     break ; 
  1157.   case 246 : 
  1158.   case 247 : 
  1159.     mathac () ; 
  1160.     break ; 
  1161.   case 257 : 
  1162.     {
  1163.       scanspec () ; 
  1164.       newsavelevel ( 12 ) ; 
  1165.       normalparagraph () ; 
  1166.       pushnest () ; 
  1167.       curlist .modefield = -1 ; 
  1168.       curlist .auxfield = -65536000L ; 
  1169.       if ( eqtb [ 4062 ] .hh .v.RH != 0 ) 
  1170.       begintokenlist ( eqtb [ 4062 ] .hh .v.RH , 11 ) ; 
  1171.     } 
  1172.     break ; 
  1173.   case 254 : 
  1174.     {
  1175.       mem [ curlist .tailfield ] .hh .v.RH = newstyle ( curchr ) ; 
  1176.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1177.     } 
  1178.     break ; 
  1179.   case 256 : 
  1180.     {
  1181.       {
  1182.     mem [ curlist .tailfield ] .hh .v.RH = newglue ( 0 ) ; 
  1183.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1184.       } 
  1185.       mem [ curlist .tailfield ] .hh.b1 = 98 ; 
  1186.     } 
  1187.     break ; 
  1188.   case 255 : 
  1189.     appendchoices () ; 
  1190.     break ; 
  1191.   case 209 : 
  1192.   case 208 : 
  1193.     subsup () ; 
  1194.     break ; 
  1195.   case 253 : 
  1196.     mathfraction () ; 
  1197.     break ; 
  1198.   case 250 : 
  1199.     mathleftright () ; 
  1200.     break ; 
  1201.   case 204 : 
  1202.     if ( curgroup == 15 ) 
  1203.     aftermath () ; 
  1204.     else offsave () ; 
  1205.     break ; 
  1206.   case 71 : 
  1207.   case 171 : 
  1208.   case 271 : 
  1209.   case 72 : 
  1210.   case 172 : 
  1211.   case 272 : 
  1212.   case 73 : 
  1213.   case 173 : 
  1214.   case 273 : 
  1215.   case 74 : 
  1216.   case 174 : 
  1217.   case 274 : 
  1218.   case 75 : 
  1219.   case 175 : 
  1220.   case 275 : 
  1221.   case 76 : 
  1222.   case 176 : 
  1223.   case 276 : 
  1224.   case 77 : 
  1225.   case 177 : 
  1226.   case 277 : 
  1227.   case 78 : 
  1228.   case 178 : 
  1229.   case 278 : 
  1230.   case 79 : 
  1231.   case 179 : 
  1232.   case 279 : 
  1233.   case 80 : 
  1234.   case 180 : 
  1235.   case 280 : 
  1236.   case 81 : 
  1237.   case 181 : 
  1238.   case 281 : 
  1239.   case 82 : 
  1240.   case 182 : 
  1241.   case 282 : 
  1242.   case 83 : 
  1243.   case 183 : 
  1244.   case 283 : 
  1245.   case 84 : 
  1246.   case 184 : 
  1247.   case 284 : 
  1248.   case 85 : 
  1249.   case 185 : 
  1250.   case 285 : 
  1251.   case 86 : 
  1252.   case 186 : 
  1253.   case 286 : 
  1254.   case 87 : 
  1255.   case 187 : 
  1256.   case 287 : 
  1257.   case 88 : 
  1258.   case 188 : 
  1259.   case 288 : 
  1260.   case 89 : 
  1261.   case 189 : 
  1262.   case 289 : 
  1263.   case 90 : 
  1264.   case 190 : 
  1265.   case 290 : 
  1266.   case 91 : 
  1267.   case 191 : 
  1268.   case 291 : 
  1269.   case 92 : 
  1270.   case 192 : 
  1271.   case 292 : 
  1272.   case 93 : 
  1273.   case 193 : 
  1274.   case 293 : 
  1275.   case 94 : 
  1276.   case 194 : 
  1277.   case 294 : 
  1278.   case 95 : 
  1279.   case 195 : 
  1280.   case 295 : 
  1281.   case 96 : 
  1282.   case 196 : 
  1283.   case 296 : 
  1284.   case 97 : 
  1285.   case 197 : 
  1286.   case 297 : 
  1287.   case 98 : 
  1288.   case 198 : 
  1289.   case 298 : 
  1290.   case 99 : 
  1291.   case 199 : 
  1292.   case 299 : 
  1293.   case 100 : 
  1294.   case 200 : 
  1295.   case 300 : 
  1296.     prefixedcommand () ; 
  1297.     break ; 
  1298.   case 41 : 
  1299.   case 141 : 
  1300.   case 241 : 
  1301.     {
  1302.       gettoken () ; 
  1303.       aftertoken = curtok ; 
  1304.     } 
  1305.     break ; 
  1306.   case 42 : 
  1307.   case 142 : 
  1308.   case 242 : 
  1309.     {
  1310.       gettoken () ; 
  1311.       saveforafter ( curtok ) ; 
  1312.     } 
  1313.     break ; 
  1314.   case 61 : 
  1315.   case 161 : 
  1316.   case 261 : 
  1317.     openorclosein () ; 
  1318.     break ; 
  1319.   case 59 : 
  1320.   case 159 : 
  1321.   case 259 : 
  1322.     issuemessage () ; 
  1323.     break ; 
  1324.   case 58 : 
  1325.   case 158 : 
  1326.   case 258 : 
  1327.     shiftcase () ; 
  1328.     break ; 
  1329.   case 20 : 
  1330.   case 120 : 
  1331.   case 220 : 
  1332.     showwhatever () ; 
  1333.     break ; 
  1334.   case 60 : 
  1335.   case 160 : 
  1336.   case 260 : 
  1337.     doextension () ; 
  1338.     break ; 
  1339.   } 
  1340.   goto lab60 ; 
  1341.   lab70: f = eqtb [ 4578 ] .hh .v.RH ; 
  1342.   c = curchr ; 
  1343.   lab71: if ( ( c < fontbc [ f ] ) || ( c > fontec [ f ] ) ) 
  1344.   {
  1345.     charwarning ( f , c ) ; 
  1346.     goto lab60 ; 
  1347.   } 
  1348.   lab72: q = curlist .tailfield ; 
  1349.   ligaturepresent = false ; 
  1350.   l = c ; 
  1351.   lab73: if ( c < 128 ) 
  1352.   {
  1353.     s = eqtb [ 5011 + c ] .hh .v.RH ; 
  1354.     if ( s == 1000 ) 
  1355.     curlist .auxfield = 1000 ; 
  1356.     else if ( s < 1000 ) 
  1357.     {
  1358.       if ( s > 0 ) 
  1359.       curlist .auxfield = s ; 
  1360.     } 
  1361.     else if ( curlist .auxfield < 1000 ) 
  1362.     curlist .auxfield = 1000 ; 
  1363.     else curlist .auxfield = s ; 
  1364.   } 
  1365.   else curlist .auxfield = 1000 ; 
  1366.   i = fontinfo [ charbase [ f ] + l ] .qqqq ; 
  1367.   if ( ( i .b0 > 0 ) ) 
  1368.   {
  1369.     {
  1370.       p = avail ; 
  1371.       if ( p == 0 ) 
  1372.       p = getavail () ; 
  1373.       else {
  1374.       
  1375.     avail = mem [ p ] .hh .v.RH ; 
  1376.     mem [ p ] .hh .v.RH = 0 ; 
  1377.     ;
  1378. #ifdef STAT
  1379.     incr ( dynused ) ; 
  1380. #endif /* STAT */
  1381.       } 
  1382.     } 
  1383.     mem [ p ] .hh.b0 = f ; 
  1384.     mem [ p ] .hh.b1 = c ; 
  1385.     mem [ curlist .tailfield ] .hh .v.RH = p ; 
  1386.     curlist .tailfield = p ; 
  1387.   } 
  1388.   else charwarning ( f , l ) ; 
  1389.   getnext () ; 
  1390.   if ( curcmd == 11 ) 
  1391.   r = curchr ; 
  1392.   else if ( curcmd == 12 ) 
  1393.   r = curchr ; 
  1394.   else if ( curcmd == 67 ) 
  1395.   r = curchr ; 
  1396.   else {
  1397.       
  1398.     xtoken () ; 
  1399.     if ( ( curcmd == 11 ) || ( curcmd == 12 ) || ( curcmd == 67 ) ) 
  1400.     r = curchr ; 
  1401.     else if ( curcmd == 16 ) 
  1402.     {
  1403.       scancharnum () ; 
  1404.       r = curval ; 
  1405.     } 
  1406.     else r = 256 ; 
  1407.   } 
  1408.   if ( ( ( i .b2 ) % 4 ) == 1 ) 
  1409.   if ( r != 256 ) 
  1410.   {
  1411.     k = ligkernbase [ f ] + i .b3 ; 
  1412.     do {
  1413.     j = fontinfo [ k ] .qqqq ; 
  1414.       if ( j .b1 == r ) 
  1415.       if ( j .b2 < 128 ) 
  1416.       {
  1417.     ligaturepresent = true ; 
  1418.     l = j .b3 ; 
  1419.     c = r ; 
  1420.     goto lab73 ; 
  1421.       } 
  1422.       else {
  1423.       
  1424.     if ( ligaturepresent ) 
  1425.     {
  1426.       p = newligature ( f , l , mem [ q ] .hh .v.RH ) ; 
  1427.       mem [ q ] .hh .v.RH = p ; 
  1428.       curlist .tailfield = p ; 
  1429.     } 
  1430.     if ( c == hyphenchar [ f ] ) 
  1431.     if ( curlist .modefield == 101 ) 
  1432.     {
  1433.       mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  1434.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1435.     } 
  1436.     {
  1437.       mem [ curlist .tailfield ] .hh .v.RH = newkern ( fontinfo [ kernbase 
  1438.       [ f ] + j .b3 ] .cint ) ; 
  1439.       curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1440.     } 
  1441.     c = r ; 
  1442.     goto lab72 ; 
  1443.       } 
  1444.       incr ( k ) ; 
  1445.     } while ( ! ( j .b0 >= 128 ) ) ; 
  1446.   } 
  1447.   if ( ligaturepresent ) 
  1448.   {
  1449.     p = newligature ( f , l , mem [ q ] .hh .v.RH ) ; 
  1450.     mem [ q ] .hh .v.RH = p ; 
  1451.     curlist .tailfield = p ; 
  1452.   } 
  1453.   if ( c == hyphenchar [ f ] ) 
  1454.   if ( curlist .modefield == 101 ) 
  1455.   {
  1456.     mem [ curlist .tailfield ] .hh .v.RH = newdisc () ; 
  1457.     curlist .tailfield = mem [ curlist .tailfield ] .hh .v.RH ; 
  1458.   } 
  1459.   if ( r == 256 ) 
  1460.   goto lab21 ; 
  1461.   c = r ; 
  1462.   goto lab71 ; 
  1463.   lab74: if ( eqtb [ 3538 ] .hh .v.RH == 0 ) 
  1464.   {
  1465.     {
  1466.       p = fontglue [ eqtb [ 4578 ] .hh .v.RH ] ; 
  1467.       if ( p == 0 ) 
  1468.       {
  1469.     f = eqtb [ 4578 ] .hh .v.RH ; 
  1470.     p = newspec ( 0 ) ; 
  1471.     k = parambase [ f ] + 2 ; 
  1472.     mem [ p + 1 ] .cint = fontinfo [ k ] .cint ; 
  1473.     mem [ p + 2 ] .cint = fontinfo [ k + 1 ] .cint ; 
  1474.     mem [ p + 3 ] .cint = fontinfo [ k + 2 ] .cint ; 
  1475.     fontglue [ f ] = p ; 
  1476.       } 
  1477.     } 
  1478.     q = newglue ( p ) ; 
  1479.   } 
  1480.   else q = newparamglue ( 12 ) ; 
  1481.   mem [ curlist .tailfield ] .hh .v.RH = q ; 
  1482.   curlist .tailfield = q ; 
  1483.   goto lab60 ; 
  1484. } 
  1485. giveerrhelp () {
  1486.     giveerrhelp_regmem 
  1487.   tokenshow ( eqtb [ 4065 ] .hh .v.RH ) ; 
  1488. } 
  1489. boolean openfmtfile () {
  1490.     /* 40 10 */ register boolean Result; 
  1491.   openfmtfile_regmem 
  1492.   integer j  ; 
  1493.   j = curinput .locfield ; 
  1494.   if ( buffer [ curinput .locfield ] == 38 ) 
  1495.   {
  1496.     incr ( curinput .locfield ) ; 
  1497.     j = curinput .locfield ; 
  1498.     buffer [ last ] = 32 ; 
  1499.     while ( buffer [ j ] != 32 ) incr ( j ) ; 
  1500.     packbufferedname ( 0 , curinput .locfield , j - 1 ) ; 
  1501.     if ( wopenin ( fmtfile ) ) 
  1502.     goto lab40 ; 
  1503.     wakeupterminal () ; 
  1504. #ifdef RISC_OS
  1505.     (void) Fputs( stdout , "Sorry, I can't find that format; will try PLAIN."); 
  1506. #else
  1507.     (void) fprintf( stdout , "%s%s\n",  "Sorry, I can't find that format;" , " will try PLAIN."     ) ; 
  1508. #endif
  1509.     termflush ( stdout ) ; 
  1510.   } 
  1511.   packbufferedname ( 5 , 1 , 0 ) ; 
  1512.   if ( ! wopenin ( fmtfile ) ) 
  1513.   {
  1514.     wakeupterminal () ; 
  1515. #ifdef RISC_OS
  1516.     (void) Fputs( stdout , "I can't find the PLAIN format file!" ) ;
  1517. #else
  1518.     (void) fprintf( stdout , "%s\n",  "I can't find the PLAIN format file!" ) ;
  1519. #endif 
  1520.     Result = false ; 
  1521.     return(Result) ; 
  1522.   } 
  1523.   lab40: curinput .locfield = j ; 
  1524.   Result = true ; 
  1525.   return(Result) ; 
  1526. } 
  1527. boolean loadfmtfile () {
  1528.     /* 6666 10 */ register boolean Result; 
  1529.   loadfmtfile_regmem 
  1530.   integer j, k  ; 
  1531.   halfword p, q  ; 
  1532.   integer x  ; 
  1533.   getfmtint ( x ) ; 
  1534.   if ( x != 67218746L ) 
  1535.   goto lab6666 ; 
  1536.   getfmtint ( x ) ; 
  1537.   if ( x != 0 ) 
  1538.   goto lab6666 ; 
  1539.   getfmtint ( x ) ; 
  1540.   if ( x != memtop ) 
  1541.   goto lab6666 ; 
  1542.   getfmtint ( x ) ; 
  1543.   if ( x != 5976 ) 
  1544.   goto lab6666 ; 
  1545.   getfmtint ( x ) ; 
  1546.   if ( x != 2551 ) 
  1547.   goto lab6666 ; 
  1548.   getfmtint ( x ) ; 
  1549.   if ( x != 307 ) 
  1550.   goto lab6666 ; 
  1551.   {
  1552.     getfmtint ( x ) ; 
  1553.     if ( x < 0 ) 
  1554.     goto lab6666 ; 
  1555.     if ( x > poolsize ) 
  1556.     {
  1557.       wakeupterminal () ; 
  1558. #ifdef RISC_OS
  1559.       (void) Fputs( stdout , "---! Must increase the string pool size" ) ; 
  1560. #else
  1561.       (void) fprintf( stdout , "%s%s\n",  "---! Must increase the " , "string pool size" ) ; 
  1562. #endif
  1563.       goto lab6666 ; 
  1564.     } 
  1565.     else poolptr = x ; 
  1566.   } 
  1567.   {
  1568.     getfmtint ( x ) ; 
  1569.     if ( x < 0 ) 
  1570.     goto lab6666 ; 
  1571.     if ( x > maxstrings ) 
  1572.     {
  1573.       wakeupterminal () ; 
  1574. #ifdef RISC_OS
  1575.       (void) Fputs( stdout , "---! Must increase the max strings" ) ; 
  1576. #else
  1577.       (void) fprintf( stdout , "%s%s\n",  "---! Must increase the " , "max strings" ) ; 
  1578. #endif
  1579.       goto lab6666 ; 
  1580.     } 
  1581.     else strptr = x ; 
  1582.   } 
  1583.   undumpthings ( strstart [ 0 ] , strptr + 1 ) ; 
  1584.   undumpthings ( strpool [ 0 ] , poolptr ) ; 
  1585.   {
  1586.     getfmtint ( x ) ; 
  1587.     if ( ( x < 1019 ) || ( x > memtop - 14 ) ) 
  1588.     goto lab6666 ; 
  1589.     else lomemmax = x ; 
  1590.   } 
  1591.   {
  1592.     getfmtint ( x ) ; 
  1593.     if ( ( x < 20 ) || ( x > lomemmax ) ) 
  1594.     goto lab6666 ; 
  1595.     else rover = x ; 
  1596.   } 
  1597.   p = 0 ; 
  1598.   q = rover ; 
  1599.   x = 0 ; 
  1600.   do {
  1601.       undumpthings ( mem [ p ] , q + 2 - p ) ; 
  1602.     p = q + mem [ q ] .hh .v.LH ; 
  1603.     if ( ( p > lomemmax ) || ( ( q >= mem [ q + 1 ] .hh .v.RH ) && ( mem [ q + 
  1604.     1 ] .hh .v.RH != rover ) ) ) 
  1605.     goto lab6666 ; 
  1606.     q = mem [ q + 1 ] .hh .v.RH ; 
  1607.   } while ( ! ( q == rover ) ) ; 
  1608.   undumpthings ( mem [ p ] , lomemmax + 1 - p ) ; 
  1609.   if ( memmin < -2 ) 
  1610.   {
  1611.     p = mem [ rover + 1 ] .hh .v.LH ; 
  1612.     q = memmin + 1 ; 
  1613.     mem [ memmin ] .hh .v.RH = 0 ; 
  1614.     mem [ memmin ] .hh .v.LH = 0 ; 
  1615.     mem [ p + 1 ] .hh .v.RH = q ; 
  1616.     mem [ rover + 1 ] .hh .v.LH = q ; 
  1617.     mem [ q + 1 ] .hh .v.RH = rover ; 
  1618.     mem [ q + 1 ] .hh .v.LH = p ; 
  1619.     mem [ q ] .hh .v.RH = 65535L ; 
  1620.     mem [ q ] .hh .v.LH = -0 - q ; 
  1621.   } 
  1622.   {
  1623.     getfmtint ( x ) ; 
  1624.     if ( ( x < lomemmax + 1 ) || ( x > memtop - 13 ) ) 
  1625.     goto lab6666 ; 
  1626.     else himemmin = x ; 
  1627.   } 
  1628.   {
  1629.     getfmtint ( x ) ; 
  1630.     if ( ( x < 0 ) || ( x > memtop ) ) 
  1631.     goto lab6666 ; 
  1632.     else avail = x ; 
  1633.   } 
  1634.   memend = memtop ; 
  1635.   undumpthings ( mem [ himemmin ] , memend + 1 - himemmin ) ; 
  1636.   getfmtint ( varused ) ; 
  1637.   getfmtint ( dynused ) ; 
  1638.   k = 1 ; 
  1639.   do {
  1640.       getfmtint ( x ) ; 
  1641.     if ( ( x < 1 ) || ( k + x > 5977 ) ) 
  1642.     goto lab6666 ; 
  1643.     undumpthings ( eqtb [ k ] , x ) ; 
  1644.     k = k + x ; 
  1645.     getfmtint ( x ) ; 
  1646.     if ( ( x < 0 ) || ( k + x > 5977 ) ) 
  1647.     goto lab6666 ; 
  1648.     {register integer for_end; j = k ; for_end = k + x - 1 ; if ( j <= 
  1649.     for_end) do 
  1650.       eqtb [ j ] = eqtb [ k - 1 ] ; 
  1651.     while ( j++ < for_end ) ; } 
  1652.     k = k + x ; 
  1653.   } while ( ! ( k > 5976 ) ) ; 
  1654.   {
  1655.     getfmtint ( x ) ; 
  1656.     if ( ( x < 258 ) || ( x > 3258 ) ) 
  1657.     goto lab6666 ; 
  1658.     else parloc = x ; 
  1659.   } 
  1660.   partoken = 4096 + parloc ; 
  1661.   {
  1662.     getfmtint ( x ) ; 
  1663.     if ( ( x < 258 ) || ( x > 3258 ) ) 
  1664.     goto lab6666 ; 
  1665.     else
  1666.     writeloc = x ; 
  1667.   } 
  1668.   {
  1669.     getfmtint ( x ) ; 
  1670.     if ( ( x < 258 ) || ( x > 3258 ) ) 
  1671.     goto lab6666 ; 
  1672.     else hashused = x ; 
  1673.   } 
  1674.   p = 257 ; 
  1675.   do {
  1676.       { 
  1677.       getfmtint ( x ) ; 
  1678.       if ( ( x < p + 1 ) || ( x > hashused ) ) 
  1679.       goto lab6666 ; 
  1680.       else p = x ; 
  1681.     } 
  1682.     getfmthh ( hash [ p ] ) ; 
  1683.   } while ( ! ( p == hashused ) ) ; 
  1684.   undumpthings ( hash [ hashused + 1 ] , 3524 - hashused ) ; 
  1685.   getfmtint ( cscount ) ; 
  1686.   {
  1687.     getfmtint ( x ) ; 
  1688.     if ( x < 7 ) 
  1689.     goto lab6666 ; 
  1690.     if ( x > fontmemsize ) 
  1691.     {
  1692.       wakeupterminal () ; 
  1693. #ifdef RISC_OS
  1694.       (void) Fputs( stdout , "---! Must increase the font mem size" ) ; 
  1695. #else
  1696.       (void) fprintf( stdout , "%s%s\n",  "---! Must increase the " , "font mem size" ) ; 
  1697. #endif
  1698.       goto lab6666 ; 
  1699.     } 
  1700.     else fmemptr = x ; 
  1701.   } 
  1702.   {
  1703.     undumpthings ( fontinfo [ 0 ] , fmemptr ) ; 
  1704.     {
  1705.       getfmtint ( x ) ; 
  1706.       if ( x < 0 ) 
  1707.       goto lab6666 ; 
  1708.       if ( x > fontmax ) 
  1709.       {
  1710.     wakeupterminal () ; 
  1711. #ifdef RISC_OS
  1712.     (void) Fputs( stdout , "---! Must increase the font max" ) ;
  1713. #else
  1714.     (void) fprintf( stdout , "%s%s\n",  "---! Must increase the " , "font max" ) ;
  1715. #endif 
  1716.     goto lab6666 ; 
  1717.       } 
  1718.       else fontptr = x ; 
  1719.     } 
  1720.     undumpthings ( fontcheck [ 0 ] , fontptr + 1 ) ; 
  1721.     undumpthings ( fontsize [ 0 ] , fontptr + 1 ) ; 
  1722.     undumpthings ( fontdsize [ 0 ] , fontptr + 1 ) ; 
  1723.     undumpthings ( fontparams [ 0 ] , fontptr + 1 ) ; 
  1724.     undumpthings ( hyphenchar [ 0 ] , fontptr + 1 ) ; 
  1725.     undumpthings ( skewchar [ 0 ] , fontptr + 1 ) ; 
  1726.     undumpthings ( fontname [ 0 ] , fontptr + 1 ) ; 
  1727.     undumpthings ( fontarea [ 0 ] , fontptr + 1 ) ; 
  1728.     undumpthings ( fontbc [ 0 ] , fontptr + 1 ) ; 
  1729.     undumpthings ( fontec [ 0 ] , fontptr + 1 ) ; 
  1730.     undumpthings ( charbase [ 0 ] , fontptr + 1 ) ; 
  1731.     undumpthings ( widthbase [ 0 ] , fontptr + 1 ) ; 
  1732.     undumpthings ( heightbase [ 0 ] , fontptr + 1 ) ; 
  1733.     undumpthings ( depthbase [ 0 ] , fontptr + 1 ) ; 
  1734.     undumpthings ( italicbase [ 0 ] , fontptr + 1 ) ; 
  1735.     undumpthings ( ligkernbase [ 0 ] , fontptr + 1 ) ; 
  1736.     undumpthings ( kernbase [ 0 ] , fontptr + 1 ) ; 
  1737.     undumpthings ( extenbase [ 0 ] , fontptr + 1 ) ; 
  1738.     undumpthings ( parambase [ 0 ] , fontptr + 1 ) ; 
  1739.     undumpthings ( fontglue [ 0 ] , fontptr + 1 ) ; 
  1740.   } 
  1741.   {
  1742.     getfmtint ( x ) ; 
  1743.     if ( ( x < 0 ) || ( x > 307 ) ) 
  1744.     goto lab6666 ; 
  1745.     else hyphcount = x ; 
  1746.   } 
  1747.   {register integer for_end; k = 1 ; for_end = hyphcount ; if ( k <= for_end) 
  1748.   do 
  1749.     {
  1750.       {
  1751.     getfmtint ( x ) ; 
  1752.     if ( ( x < 0 ) || ( x > 307 ) ) 
  1753.     goto lab6666 ; 
  1754.     else j = x ; 
  1755.       } 
  1756.       {
  1757.     getfmtint ( x ) ; 
  1758.     if ( ( x < 0 ) || ( x > strptr ) ) 
  1759.     goto lab6666 ; 
  1760.     else hyphword [ j ] = x ; 
  1761.       } 
  1762.       {
  1763.     getfmtint ( x ) ; 
  1764.     if ( ( x < 0 ) || ( x > 65535L ) ) 
  1765.     goto lab6666 ; 
  1766.     else hyphlist [ j ] = x ; 
  1767.       } 
  1768.     } 
  1769.   while ( k++ < for_end ) ; } 
  1770.   {
  1771.     getfmtint ( x ) ; 
  1772.     if ( x < 0 ) 
  1773.     goto lab6666 ; 
  1774.     if ( x > triesize ) 
  1775.     {
  1776.       wakeupterminal () ; 
  1777. #ifdef RISC_OS
  1778.       (void) Fputs( stdout , "---! Must increase the trie size" ) ; 
  1779. #else
  1780.       (void) fprintf( stdout , "%s%s\n",  "---! Must increase the " , "trie size" ) ; 
  1781. #endif
  1782.       goto lab6666 ; 
  1783.     } 
  1784.     else triemax = x ; 
  1785.   } 
  1786.   undumpthings ( trie [ 0 ] , triemax + 1 ) ; 
  1787.   {
  1788.     getfmtint ( x ) ; 
  1789.     if ( ( x < 0 ) || ( x > 255 ) ) 
  1790.     goto lab6666 ; 
  1791.     else trieopptr = x ; 
  1792.   } 
  1793.   undumpthings ( hyfdistance [ 1 ] , trieopptr - 0 ) ; 
  1794.   undumpthings ( hyfnum [ 1 ] , trieopptr - 0 ) ; 
  1795.   undumpthings ( hyfnext [ 1 ] , trieopptr - 0 ) ; 
  1796.   {
  1797.     getfmtint ( x ) ; 
  1798.     if ( ( x < 0 ) || ( x > 3 ) ) 
  1799.     goto lab6666 ; 
  1800.     else interaction = x ; 
  1801.   } 
  1802.   {
  1803.     getfmtint ( x ) ; 
  1804.     if ( ( x < 0 ) || ( x > strptr ) ) 
  1805.     goto lab6666 ; 
  1806.     else formatident = x ; 
  1807.   } 
  1808.   getfmtint ( x ) ; 
  1809.   if ( ( x != 69069L ) || eof ( fmtfile ) ) 
  1810.   goto lab6666 ; 
  1811.   Result = true ; 
  1812.   return(Result) ; 
  1813.   lab6666: wakeupterminal () ; 
  1814. #ifdef RISC_OS
  1815.   (void) Fputs( stdout , "(Fatal format file error; I'm stymied)" );
  1816. #else
  1817.   (void) fprintf( stdout , "%s\n",  "(Fatal format file error; I'm stymied)" );
  1818. #endif 
  1819.   Result = false ; 
  1820.   return(Result) ; 
  1821. } 
  1822. closefilesandtermina () {
  1823.     closefilesandtermina_regmem 
  1824.   integer k  ; 
  1825.   {register integer for_end; k = 0 ; for_end = 15 ; if ( k <= for_end) do 
  1826.     if ( writeopen [ k ] ) 
  1827.     aclose ( writefile [ k ] ) ; 
  1828.   while ( k++ < for_end ) ; } 
  1829.     ;
  1830. #ifdef STAT
  1831.   if ( eqtb [ 5298 ] .cint > 0 ) 
  1832.   if ( jobname > 0 ) 
  1833.   {
  1834.     (void) fprintf( logfile , "%c\n",  ' ' ) ; 
  1835.     (void) fprintf( logfile , "%s%s\n",  "Here is how much of TeX's memory" , " you used:" ) ; 
  1836.     (void) fprintf( logfile , "%c%ld%s",  ' ' , (long)strptr - initstrptr , " string" ) ; 
  1837.     if ( strptr != initstrptr + 1 ) 
  1838.     (void) putc( 's' ,  logfile );
  1839.     (void) fprintf( logfile , "%s%ld\n",  " out of " , (long)maxstrings - initstrptr ) ; 
  1840.     (void) fprintf( logfile , "%c%ld%s%ld\n",  ' ' , (long)poolptr - initpoolptr ,     " string characters out of " , (long)poolsize - initpoolptr ) ; 
  1841.     (void) fprintf( logfile , "%c%ld%s%ld\n",  ' ' , (long)lomemmax - memmin + memend - himemmin + 2 ,     " words of memory out of " , (long)memend + 1 - memmin ) ; 
  1842.     (void) fprintf( logfile , "%c%ld%s%ld\n",  ' ' , (long)cscount ,     " multiletter control sequences out of " , (long)3000 ) ; 
  1843.     (void) fprintf( logfile , "%c%ld%s%ld%s",  ' ' , (long)fmemptr , " words of font info for " , (long)fontptr - 0     , " font" ) ; 
  1844.     if ( fontptr != 1 ) 
  1845.     (void) putc( 's' ,  logfile );
  1846.     (void) fprintf( logfile , "%s%ld%s%ld\n",  ", out of " , (long)fontmemsize , " for " , (long)fontmax - 0 ) ; 
  1847.     (void) fprintf( logfile , "%c%ld%s",  ' ' , (long)hyphcount , " hyphenation exception" ) ; 
  1848.     if ( hyphcount != 1 ) 
  1849.     (void) putc( 's' ,  logfile );
  1850.     (void) fprintf( logfile , "%s%ld\n",  " out of " , (long)307 ) ; 
  1851.     (void) fprintf( logfile , "%c%ld%s%ld%s%ld%s%ld%s%ld%s%ld%s%ld%s%ld%s%ld%s%ld%c\n",  ' ' , (long)maxinstack , "i," , (long)maxneststack , "n," ,     (long)maxparamstack , "p," , (long)maxbufstack + 1 , "b," , (long)maxsavestack + 6 ,     "s stack positions out of " , (long)stacksize , "i," , (long)nestsize , "n," ,     (long)paramsize , "p," , (long)bufsize , "b," , (long)savesize , 's' ) ; 
  1852.   } 
  1853. #endif /* STAT */
  1854.   while ( curs > -1 ) {
  1855.       
  1856.     if ( curs > 0 ) 
  1857.     {
  1858.       dvibuf [ dviptr ] = 142 ; 
  1859.       incr ( dviptr ) ; 
  1860.       if ( dviptr == dvilimit ) 
  1861.       dviswap () ; 
  1862.     } 
  1863.     else {
  1864.     
  1865.       {
  1866.     dvibuf [ dviptr ] = 140 ; 
  1867.     incr ( dviptr ) ; 
  1868.     if ( dviptr == dvilimit ) 
  1869.     dviswap () ; 
  1870.       } 
  1871.       incr ( totalpages ) ; 
  1872.     } 
  1873.     decr ( curs ) ; 
  1874.   } 
  1875.   if ( totalpages == 0 ) 
  1876.   printnl ( 690 ) ; 
  1877.   else {
  1878.       
  1879.     {
  1880.       dvibuf [ dviptr ] = 248 ; 
  1881.       incr ( dviptr ) ; 
  1882.       if ( dviptr == dvilimit ) 
  1883.       dviswap () ; 
  1884.     } 
  1885.     dvifour ( lastbop ) ; 
  1886.     lastbop = dvioffset + dviptr - 5 ; 
  1887.     dvifour ( 25400000L ) ; 
  1888.     dvifour ( 473628672L ) ; 
  1889.     preparemag () ; 
  1890.     dvifour ( eqtb [ 5284 ] .cint ) ; 
  1891.     dvifour ( maxv ) ; 
  1892.     dvifour ( maxh ) ; 
  1893.     {
  1894.       dvibuf [ dviptr ] = maxpush / 256 ; 
  1895.       incr ( dviptr ) ; 
  1896.       if ( dviptr == dvilimit ) 
  1897.       dviswap () ; 
  1898.     } 
  1899.     {
  1900.       dvibuf [ dviptr ] = maxpush % 256 ; 
  1901.       incr ( dviptr ) ; 
  1902.       if ( dviptr == dvilimit ) 
  1903.       dviswap () ; 
  1904.     } 
  1905.     {
  1906.       dvibuf [ dviptr ] = totalpages / 256 ; 
  1907.       incr ( dviptr ) ; 
  1908.       if ( dviptr == dvilimit ) 
  1909.       dviswap () ; 
  1910.     } 
  1911.     {
  1912.       dvibuf [ dviptr ] = totalpages % 256 ; 
  1913.       incr ( dviptr ) ; 
  1914.       if ( dviptr == dvilimit ) 
  1915.       dviswap () ; 
  1916.     } 
  1917.     while ( fontptr > 0 ) {
  1918.     
  1919.       if ( fontused [ fontptr ] ) 
  1920.       dvifontdef ( fontptr ) ; 
  1921.       decr ( fontptr ) ; 
  1922.     } 
  1923.     {
  1924.       dvibuf [ dviptr ] = 249 ; 
  1925.       incr ( dviptr ) ; 
  1926.       if ( dviptr == dvilimit ) 
  1927.       dviswap () ; 
  1928.     } 
  1929.     dvifour ( lastbop ) ; 
  1930.     {
  1931.       dvibuf [ dviptr ] = 2 ; 
  1932.       incr ( dviptr ) ; 
  1933.       if ( dviptr == dvilimit ) 
  1934.       dviswap () ; 
  1935.     } 
  1936.     k = 4 + ( ( dvibufsize - dviptr ) % 4 ) ; 
  1937.     while ( k > 0 ) {
  1938.     
  1939.       {
  1940.     dvibuf [ dviptr ] = 223 ; 
  1941.     incr ( dviptr ) ; 
  1942.     if ( dviptr == dvilimit ) 
  1943.     dviswap () ; 
  1944.       } 
  1945.       decr ( k ) ; 
  1946.     } 
  1947.     if ( dvilimit == halfbuf ) 
  1948.     writedvi ( halfbuf , dvibufsize - 1 ) ; 
  1949.     if ( dviptr > 0 ) 
  1950.     writedvi ( 0 , dviptr - 1 ) ; 
  1951.     printnl ( 691 ) ; 
  1952.     print ( outputfilename ) ; 
  1953.     print ( 155 ) ; 
  1954.     printint ( totalpages ) ; 
  1955.     print ( 692 ) ; 
  1956.     if ( totalpages != 1 ) 
  1957.     printchar ( 115 ) ; 
  1958.     print ( 693 ) ; 
  1959.     printint ( dvioffset + dviptr ) ; 
  1960.     print ( 694 ) ; 
  1961.     bclose ( dvifile ) ; 
  1962.   } 
  1963.   if ( jobname > 0 ) 
  1964.   {
  1965.     (void) putc('\n',  logfile );
  1966.     aclose ( logfile ) ; 
  1967.     selector = selector - 2 ; 
  1968.     if ( selector == 17 ) 
  1969.     {
  1970.       printnl ( 1120 ) ; 
  1971.       print ( logname ) ; 
  1972.       printchar ( 46 ) ; 
  1973.     } 
  1974.   } 
  1975.   println () ; 
  1976.   if ( ( editnamestart != 0 ) && ( interaction > 0 ) ) 
  1977.   calledit ( strpool , editnamestart , editnamelength , editline ) ; 
  1978. } 
  1979. #ifdef DEBUG
  1980. debughelp () {
  1981.     /* 888 10 */ debughelp_regmem 
  1982.   integer k, l, m, n  ; 
  1983.   while ( true ) {
  1984.       
  1985.     wakeupterminal () ; 
  1986.     printnl ( 1128 ) ; 
  1987.     termflush ( stdout ) ; 
  1988.     read ( stdin , m ) ; 
  1989.     if ( m < 0 ) 
  1990.     return ; 
  1991.     else if ( m == 0 ) 
  1992.     dumpcore () ; 
  1993.     else {
  1994.     
  1995.       read ( stdin , n ) ; 
  1996.       switch ( m ) 
  1997.       {case 1 : 
  1998.     printword ( mem [ n ] ) ; 
  1999.     break ; 
  2000.       case 2 : 
  2001.     printint ( mem [ n ] .hh .v.LH ) ; 
  2002.     break ; 
  2003.       case 3 : 
  2004.     printint ( mem [ n ] .hh .v.RH ) ; 
  2005.     break ; 
  2006.       case 4 : 
  2007.     printword ( eqtb [ n ] ) ; 
  2008.     break ; 
  2009.       case 5 : 
  2010.     printword ( fontinfo [ n ] ) ; 
  2011.     break ; 
  2012.       case 6 : 
  2013.     printword ( savestack [ n ] ) ; 
  2014.     break ; 
  2015.       case 7 : 
  2016.     showbox ( n ) ; 
  2017.     break ; 
  2018.       case 8 : 
  2019.     {
  2020.       breadthmax = 10000 ; 
  2021.       depththreshold = poolsize - poolptr - 10 ; 
  2022.       shownodelist ( n ) ; 
  2023.     } 
  2024.     break ; 
  2025.       case 9 : 
  2026.     showtokenlist ( n , 0 , 1000 ) ; 
  2027.     break ; 
  2028.       case 10 : 
  2029.     print ( n ) ; 
  2030.     break ; 
  2031.       case 11 : 
  2032.     checkmem ( n > 0 ) ; 
  2033.     break ; 
  2034.       case 12 : 
  2035.     searchmem ( n ) ; 
  2036.     break ; 
  2037.       case 13 : 
  2038.     {
  2039.       read ( stdin , l ) ; 
  2040.       printcmdchr ( n , l ) ; 
  2041.     } 
  2042.     break ; 
  2043.       case 14 : 
  2044.     {register integer for_end; k = 0 ; for_end = n ; if ( k <= for_end) 
  2045.     do 
  2046.       print ( buffer [ k ] ) ; 
  2047.     while ( k++ < for_end ) ; } 
  2048.     break ; 
  2049.       case 15 : 
  2050.     {
  2051.       fontinshortdisplay = 0 ; 
  2052.       shortdisplay ( n ) ; 
  2053.     } 
  2054.     break ; 
  2055.       case 16 : 
  2056.     panicking = ! panicking ; 
  2057.     break ; 
  2058.     default: 
  2059.     print ( 63 ) ; 
  2060.     break ; 
  2061.       } 
  2062.     } 
  2063.   } 
  2064. } 
  2065. #endif /* DEBUG */
  2066.